home *** CD-ROM | disk | FTP | other *** search
/ Mixa 155: Dogs / MIXA 155: Dogs.iso / pc / Viewer / BROWSER(W) / フィルタ / PDF / LIB / gs_ttf.ps < prev    next >
Encoding:
Text File  |  2002-10-29  |  27.0 KB  |  920 lines
  1. %    Copyright (C) 1996, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile: gs_ttf.ps,v $ $Revision: 1.13 $
  7. % Support code for direct use of TrueType fonts.
  8. % (Not needed for Type 42 fonts.)
  9.  
  10. % Note that if you want to use this file without including the ttfont.dev
  11. % option when you built Ghostscript, you will need to load the following
  12. % files before this one:
  13. %    lib/gs_mgl_e.ps
  14. %    lib/gs_mro_e.ps
  15. %    lib/gs_wan_e.ps
  16.  
  17. % Thanks to B. Jackowski and GUST (the Polish TeX Users' Group) for
  18. % the glyf-splitting code.
  19.  
  20. % ---------------- Font loading machinery ---------------- %
  21.  
  22. % Augment the FONTPATH machinery so it recognizes TrueType fonts.
  23.  
  24. /.scanfontheaders where {
  25.   pop /.scanfontheaders [
  26.    .scanfontheaders aload pop (\000\001\000\000*) (true*)
  27.   ] def
  28. } if
  29.  
  30. % <file> <key> .findfontvalue <value> true
  31. % <file> <key> .findfontvalue false
  32. % Closes the file in either case.
  33. /.findnonttfontvalue /.findfontvalue load def
  34. /.findfontvalue {
  35.   1 index read pop 2 index 1 index unread
  36.   dup 0 eq exch (t) 0 get eq or {
  37.         % If this is a font at all, it's a TrueType font.
  38.     dup /FontType eq {
  39.       pop closefile 42 true
  40.     } {
  41.       dup /FontName eq { pop .findttfontname } { pop closefile false } ifelse
  42.     } ifelse
  43.   } {
  44.         % Not a TrueType font.
  45.     .findnonttfontvalue
  46.   } ifelse
  47. } bind def
  48.  
  49. % <file> .findttfontname <fname> true
  50. % <file> .findttfontname false
  51. % Closes the file in either case.
  52. /.findttfontname {
  53.   .loadttfonttables
  54.   tabdict /name .knownget {
  55.     dup 8 getu32 f exch setfileposition
  56.     12 getu32 string f exch readstring pop
  57.     6 findname
  58.   } {
  59.     false
  60.   } ifelse
  61.   f closefile end end
  62. } bind def
  63.  
  64. % Load a font file that might be a TrueType font.
  65.  
  66. % <file> .loadfontfile -
  67. /.loadnonttfontfile /.loadfontfile load def
  68. /.loadfontfile {
  69.   dup read pop 2 copy unread 0 eq {
  70.         % If this is a font at all, it's a TrueType font.
  71.     .loadttfont pop
  72.   } {
  73.         % Not a TrueType font.
  74.     .loadnonttfontfile
  75.   } ifelse
  76. } bind def
  77.  
  78. % ---------------- Automatic Type 42 generation ---------------- %
  79.  
  80. % Load a TrueType font from a file as a Type 42 PostScript font.
  81. % The thing that makes this really messy is the handling of encodings.
  82. % There are 2 interacting tables that affect the encoding:
  83. %       'cmap' provides multiple maps from character codes to glyph indices
  84. %       'post' maps glyph indices to glyph names (if present)
  85. % What we need to get out of this is:
  86. %       Encoding mapping character codes to glyph names
  87. %         (the composition of cmap and post)
  88. %       CharStrings mapping glyph names to glyph indices
  89. %         (the inverse of post)
  90. % If the post table is missing, we have to take a guess based on the cmap
  91. % table.
  92.  
  93. /.loadttfontdict 50 dict dup begin
  94.  
  95. /orgXUID AladdinEnterprisesXUID def
  96. /maxstring 32000 def    % half the maximum length of a PostScript string,
  97.             % must be a multiple of 4 (for hmtx / loca / vmtx)
  98.  
  99. % Define the Macintosh standard mapping from characters to glyph indices.
  100. /MacRomanEncoding dup .findencoding def
  101. /MacGlyphEncoding dup .findencoding def
  102.  
  103. % Invert the MacRomanEncoding.
  104. /.romanmacdict 300 dict
  105. 0 1 MacRomanEncoding length 1 sub {
  106.   MacRomanEncoding 1 index get
  107.         % Stack: dict index charname
  108.   dup /.notdef ne {
  109.     exch 2 index 2 index .knownget {
  110.       dup type /arraytype eq {
  111.     [ exch aload pop counttomark 2 add -1 roll ]
  112.       } {
  113.     exch 2 array astore
  114.       } ifelse
  115.     } if 2 index 3 1 roll put
  116.   } {
  117.     pop pop
  118.   } ifelse
  119. } for def
  120.  
  121. % Define remapping for misnamed glyphs in TrueType 'post' tables.
  122. % There are probably a lot more than this!
  123. /postremap mark
  124.   /Cdot /Cdotaccent
  125.   /Edot /Edotaccent
  126.   /Eoverdot /Edotaccent
  127.   /Gdot /Gdotaccent
  128.   /Ldot /Ldotaccent
  129.   /Zdot /Zdotaccent
  130.   /cdot /cdotaccent 
  131.   /edot /edotaccent 
  132.   /eoverdot /edotaccent
  133.   /gdot /gdotaccent 
  134.   /ldot /ldotaccent
  135.   /zdot /zdotaccent 
  136. .dicttomark readonly def
  137.  
  138. % ---- Utilities ---- %
  139.  
  140. % Define a serial number for creating unique XUIDs for TrueType fonts.
  141. % We used to use the checkSumAdjustment value from the font, but this is
  142. % not reliable, since some fonts don't set it correctly.
  143. % Note that we must do this in a string to make it immune to save/restore.
  144. /xuidstring <80000000> def
  145. /curxuid {        % - curxuid <int>
  146.   0 xuidstring { exch 8 bitshift exch add } forall
  147. } bind def
  148. /nextxuid {        % - nextxuid -
  149.   3 -1 0 {
  150.     xuidstring 1 index 2 copy get dup 255 ne {
  151.       1 add put pop exit
  152.     } if pop 0 put pop
  153.   } for
  154. } bind def
  155.  
  156. % <string> <index> getu16 <integer>
  157. /getu16 {
  158.   2 copy get 8 bitshift 3 1 roll 1 add get add
  159. } bind def
  160.  
  161. % <string> <index> gets16 <integer>
  162. /gets16 {
  163.   getu16 16#8000 xor 16#8000 sub
  164. } bind def
  165.  
  166. % <string> <index> getu32 <integer>
  167. /getu32 {
  168.   2 copy getu16 16 bitshift 3 1 roll 2 add getu16 add
  169. } bind def
  170.  
  171. % <string> <index> gets32 <integer>
  172. /gets32 {
  173.   2 copy gets16 16 bitshift 3 1 roll 2 add getu16 add
  174. } bind def
  175.  
  176. % <string> <index> <integer> putu16 -
  177. /putu16 {
  178.   3 copy -8 bitshift put
  179.   exch 1 add exch 16#ff and put
  180. } bind def
  181.  
  182. % <string> <index> <integer> putu32 -
  183. /putu32 {
  184.   3 copy -16 bitshift putu16
  185.   exch 2 add exch 16#ffff and putu16
  186. } bind def
  187.  
  188. % <nametable> <nameid> findname <string> true
  189. % <nametable> <nameid> findname false
  190. /findname {
  191.   DEBUG { (findname: ) print dup =only  } if
  192.   false 3 1 roll 0 1 3 index 2 getu16 1 sub {
  193.         % Stack: false table id index
  194.     12 mul 6 add 2 index exch 12 getinterval
  195.     dup 6 getu16 2 index eq {
  196.         % We found the name we want.
  197.       exch pop
  198.         % Stack: false table record
  199.       dup 10 getu16 2 index 4 getu16 add
  200.       1 index 8 getu16 4 -1 roll 3 1 roll getinterval exch
  201.         % Stack: false string record
  202.         % Check for 8- vs. 16-bit characters.
  203.       is2byte { string2to1 } if true null 4 -1 roll exit
  204.     } if pop
  205.   } for pop pop
  206.   DEBUG {
  207.     dup { ( = ) print 1 index == } { ( not found) = } ifelse
  208.   } if
  209. } bind def
  210.  
  211. % <namerecord> is2byte <bool>
  212. /is2byte {
  213.   dup 0 getu16 {
  214.     { pop true }        % Apple Unicode
  215.     { pop false }        % Macintosh Script manager
  216.     { 1 getu16 1 eq }        % ISO
  217.     { 1 getu16 1 eq }        % Microsoft
  218.   } exch get exec
  219. } bind def
  220.  
  221. % <string2> string2to1 <string>
  222. /string2to1 {
  223.   dup length 2 idiv string dup
  224.   0 1 3 index length 1 sub {
  225.     3 index 1 index 2 mul 1 add get put dup
  226.   } for pop exch pop
  227. } bind def
  228.  
  229. % <array> <lt-proc> sort <array>
  230. /sort {
  231.   1 index length 1 sub -1 1 {
  232.     2 index exch 2 copy get 3 copy    % arr proc arr i arr[i] arr i arr[i]
  233.     0 1 3 index 1 sub {
  234.       3 index 1 index get    % arr proc arr i arr[i] arr imax amax j arr[j]
  235.       2 index 1 index 10 index exec {    % ... amax < arr[j]
  236.     4 2 roll
  237.       } if pop pop
  238.     } for            % arr proc arr i arr[i] arr imax amax
  239.     4 -1 roll exch 4 1 roll put put
  240.   } for pop
  241. } def
  242.  
  243. % Each procedure in this dictionary is called as follows:
  244. %       <encodingtable> proc <glypharray>
  245. /cmapformats mark
  246.   0 {        % Apple standard 1-to-1 mapping.
  247.     6 256 getinterval { } forall 256 packedarray
  248.   } bind
  249.   4 {        % Microsoft/Adobe segmented mapping.
  250.     /etab exch def
  251.     /nseg2 etab 6 getu16 def
  252.     14 /endc etab 2 index nseg2 getinterval def
  253.         % The Apple TrueType documentation omits the 2-byte
  254.         % 'reserved pad' that follows the endCount vector!
  255.     2 add
  256.     nseg2 add /startc etab 2 index nseg2 getinterval def
  257.     nseg2 add /iddelta etab 2 index nseg2 getinterval def
  258.     nseg2 add /idroff etab 2 index nseg2 getinterval def
  259.         % The following hack allows us to properly handle
  260.         % idiosyncratic fonts that start at 0xf000:
  261.     pop
  262.     /firstcode startc 0 getu16 16#ff00 and dup 16#f000 ne { pop 0 } if def
  263.     /putglyph {
  264.       glyphs code 3 -1 roll put /code code 1 add def
  265.     } bind def
  266.         % Do a first pass to compute the size of the glyphs array.
  267.     /numcodes 0 def /glyphs 0 0 2 nseg2 3 sub {
  268.         % Stack: /glyphs numglyphs i2
  269.       /i2 exch def
  270.       /scode startc i2 getu16 def
  271.       /ecode endc i2 getu16 def
  272.       numcodes scode firstcode sub
  273.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  274.       dup 16#e000 ge { 255 and } if
  275.       exch sub 0 max ecode scode sub 1 add add
  276.       exch 1 index add exch
  277.       numcodes add /numcodes exch def
  278.     } for array def
  279.         % Now fill in the array.
  280.     /numcodes 0 def /code 0 def
  281.     0 2 nseg2 3 sub {
  282.       /i2 exch def
  283.       /scode startc i2 getu16 def
  284.       /ecode endc i2 getu16 def
  285.       numcodes scode firstcode sub
  286.         % Hack for fonts that have only 0x0000 and 0xf000 ranges
  287.       dup 16#e000 ge { 255 and } if
  288.       exch sub 0 max dup { 0 putglyph } repeat
  289.       ecode scode sub 1 add add numcodes add /numcodes exch def
  290.       /delta iddelta i2 gets16 def
  291.       DEBUG {
  292.     (scode=) print scode =only
  293.     ( ecode=) print ecode =only
  294.     ( delta=) print delta =only
  295.     ( droff=) print idroff i2 getu16 =
  296.       } if
  297.       idroff i2 getu16 dup 0 eq {
  298.     pop scode delta add 65535 and 1 ecode delta add 65535 and
  299.     { putglyph } for
  300.       } {    % The +2 is for the 'reserved pad'.
  301.         /gloff exch 14 nseg2 3 mul add 2 add i2 add add def
  302.         0 1 ecode scode sub {
  303.       2 mul gloff add etab exch getu16
  304.       dup 0 ne { delta add 65535 and } if putglyph
  305.     } for
  306.       } ifelse
  307.     } for glyphs /glyphs null def    % for GC
  308.   } bind
  309.   6 {        % Single interval lookup.
  310.     dup 6 getu16 /firstcode exch def dup 8 getu16 /ng exch def
  311.     firstcode ng add array
  312.         % Stack: tab array
  313.         % Fill elements 0 .. firstcode-1 with 0
  314.     0 1 firstcode 1 sub { 2 copy 0 put pop } for
  315.     dup firstcode ng getinterval
  316.         % Stack: tab array subarray
  317.         % Fill elements firstcode .. firstcode+nvalue-1 with glyph values
  318.     0 1 ng 1 sub {
  319.       dup 2 mul 10 add 4 index exch getu16 3 copy put pop pop
  320.     } for pop exch pop
  321.   } bind
  322. .dicttomark readonly def                % cmapformats
  323.  
  324. % <cmaptab> cmaparray <glypharray>
  325. /cmaparray {
  326.   dup 0 getu16 cmapformats exch .knownget {
  327.     DEBUG {
  328.       (cmap: format ) print 1 index 0 getu16 = flush
  329.     } if exec
  330.   } {
  331.     (Can't handle format ) print 0 getu16 = flush
  332.     0 1 255 { } for 256 packedarray
  333.   } ifelse
  334.   DEBUG {
  335.     (cmap: length=) print dup length = dup ==
  336.   } if
  337. } bind def
  338.  
  339. % Each procedure in this dictionary is called as follows:
  340. %       posttable <<proc>> glyphencoding
  341. /postformats mark
  342.   16#00010000  {    % 258 standard Macintosh glyphs.
  343.     pop MacGlyphEncoding
  344.   }
  345.   16#00020000  {    % Detailed map, required by Microsoft fonts.
  346.     /postglyphs exch def
  347.       postglyphs 32 getu16 /numglyphs exch def
  348.       /glyphnames numglyphs 2 mul 34 add def
  349.       [ 0 1 numglyphs 1 sub {
  350.     2 mul 34 add postglyphs exch getu16
  351.     dup 258 lt {
  352.       MacGlyphEncoding exch get
  353.     } {
  354.       dup 32768 ge {
  355.         % According to the published TrueType spec, such values are
  356.         % "reserved for future use", but at least some PDF files
  357.         % produced by the Adobe PDF library contain entries with a
  358.         % value of 16#ffff.
  359.         pop /.notdef
  360.       } {
  361.         258 sub glyphnames exch {
  362.           postglyphs 1 index get 1 add add
  363.         } repeat
  364.         1 add postglyphs exch 2 copy 1 sub get getinterval cvn
  365.         % At least some of Microsoft's TrueType fonts use incorrect
  366.         % (Adobe-incompatible) names for some glyphs.
  367.         % Correct for this here.
  368.         postremap 1 index .knownget { exch pop } if
  369.       } ifelse
  370.     } ifelse
  371.       } for ]
  372.   } bind
  373.   16#00030000  {    % No map.
  374.     pop [ ]
  375.   } bind
  376. .dicttomark readonly def                % postformats
  377.  
  378. % Each procedure in this dictionary is called as follows:
  379. %    <file> <length> -proc- <string|array_of_strings>
  380. % Note that each table must have an even length, because of a strange
  381. % Adobe requirement that each sfnts entry have even length.
  382. /readtables mark
  383.     % Ordinary tables
  384.   (cmap) { .readtable }
  385.   (head) 1 index
  386.   (hhea) 1 index
  387.   (maxp) 1 index
  388.   (name) 1 index
  389.   (OS/2) 1 index
  390.   (post) 1 index
  391.   (vhea) 1 index
  392.     % Big tables
  393.   (glyf) { .readbigtable }
  394.   (loca) 1 index
  395.   (hmtx) 1 index
  396.   (vmtx) 1 index
  397.     % Tables only needed for embedding in PDF files
  398.   (cvt ) { .readtable }
  399.   (fpgm) 1 index
  400.   (prep) 1 index
  401. .dicttomark
  402. % Normally there would be a 'readonly' here, but the ttf2pf utility wants
  403. % to include the 'kern' table as well, so we leave the readtables dictionary
  404. % writable.
  405. def                % readtables
  406.  
  407. % Read a table as a single string.
  408. % <file> <length> .readtable <string>
  409. /.readtable {
  410.   dup dup 1 and add string
  411.         % Stack: f len str
  412.   dup 0 4 -1 roll getinterval
  413.         % Stack: f str str1
  414.   3 -1 roll exch readstring pop pop
  415. } bind def
  416.  
  417. % Read a big table (one that may exceed 64K).
  418. % <file> <length> .readbigtable <string[s]>
  419. /.readbigtable {
  420.   dup 65400 lt {
  421.     .readtable
  422.   } {
  423.     currentuserparams /VMReclaim get -2 vmreclaim
  424.     [ 4 2 roll {
  425.         % Stack: mark ... f left
  426.       dup maxstring le { exit } if
  427.       1 index maxstring string readstring pop 3 1 roll maxstring sub
  428.     } loop .readtable ]
  429.     exch vmreclaim
  430.   } ifelse
  431. } bind def
  432.  
  433. end readonly def                % .loadttfontdict
  434.  
  435. % <tab> .printtab -
  436. /.printtab {
  437.   dup 0 4 getinterval print ( ) print
  438.   dup 8 getu32 =only ( ) print
  439.   12 getu32 =
  440. } bind def
  441.  
  442. % <file> .loadttfonttables -
  443. % Pushes .loadttfontdict & scratch dict on d-stack.
  444. % Defines f, offsets, tables, tabdict, tabs.
  445. /.loadttfonttables {
  446.   .loadttfontdict begin
  447.   40 dict begin
  448.   /f exch def
  449.   /offsets f 12 string readstring pop def
  450.   /tables f offsets 4 getu16 16 mul string readstring pop def
  451.   /tabdict tables length 16 idiv dict def
  452.     % tabs = tables we want to keep, sorted by file position.
  453.   /tabs [ 0 16 tables length 1 sub {
  454.     tables exch 16 getinterval
  455.     DEBUG { dup .printtab } if
  456.     dup 0 4 getinterval readtables 1 index known {
  457.       tabdict exch 2 index put
  458.     } {
  459.       pop pop
  460.     } ifelse
  461.   } for ] {
  462.     exch 8 getu32 exch 8 getu32 lt
  463.   } sort def
  464.     % In certain malformed TrueType fonts, tables overlap.
  465.     % Truncate tables if necessary.
  466.   0 1 tabs length 2 sub {
  467.     dup tabs exch get exch 1 add tabs exch get
  468.     1 index 8 getu32 2 index 12 getu32 add
  469.     1 index 8 getu32 gt {
  470.       (**** Warning: ) print 1 index 0 4 getinterval print
  471.       ( overlaps ) print dup 0 4 getinterval print
  472.       (, truncating.) = flush
  473.       dup 8 getu32 2 index 8 getu32 sub
  474.       2 index 12 3 -1 roll putu32
  475.     } if pop pop
  476.   } for
  477. } bind def
  478.  
  479. % - .readttdata -
  480. % Read data.  Updates offsets, tabs; stores data in tabdict.
  481. /.readttdata {
  482.   /fpos offsets length tables length add def
  483.   /sfpos offsets length tabs length 16 mul add def
  484.   offsets 4 tabs length putu16
  485.   tabs {
  486.     dup 0 4 getinterval /tname exch def
  487.     dup 8 getu32 /tpos exch def
  488.     dup 12 getu32 /tlen exch def
  489.     8 sfpos putu32
  490.     % Skip data between the end of the previous table and
  491.     % the beginning of this one, if any.
  492.     tpos fpos gt {
  493.       f tpos fpos sub () /SubFileDecode filter dup flushfile closefile
  494.       /fpos tpos def
  495.     } if
  496.     f tlen readtables tname get exec
  497.     tabdict tname 3 -1 roll put
  498.     /fpos fpos tlen add def
  499.     % Round up the table length to an even value.
  500.     /sfpos sfpos tlen dup 1 and add add def
  501.   } forall
  502. } bind def
  503.  
  504. % Find the string in a list of strings that includes a given index.
  505. % <strings> <index> .findseg <string> <index'>
  506. /.findseg {
  507.   exch {
  508.     dup length 2 index gt { exch exit } if
  509.     length sub
  510.   } forall
  511. } bind def
  512.  
  513. % - .makesfnts -
  514. % Defines checksum, getloca, head, locatable, numloca, post, sfnts, upem
  515. /.makesfnts {
  516.   .readttdata
  517.   /head tabdict /head get def
  518.   /locatable tabdict /loca get def
  519.   /post tabdict /post .knownget not { null } if def
  520.   /numloca
  521.     locatable dup type /stringtype eq
  522.      { length }
  523.      { 0 exch { length add } forall }
  524.     ifelse    % no def yet
  525.   locatable type /stringtype eq {
  526.     /.indexloca {} def
  527.   } {
  528.     /.indexloca /.findseg load def
  529.   } ifelse
  530.   head 50 getu16 0 ne {
  531.     /getloca {
  532.       2 bitshift locatable exch .indexloca getu32
  533.     } def
  534.     4 idiv 1 sub
  535.   } {
  536.     /getloca {
  537.       dup add locatable exch .indexloca getu16 dup add
  538.     } def
  539.     2 idiv 1 sub
  540.   } ifelse def        % numloca
  541.     % If necessary, re-partition the glyfs.
  542.   tabdict /glyf get dup type /stringtype ne {
  543.     .dividesfnts tabdict /glyf 3 -1 roll put
  544.   } {
  545.     pop
  546.   } ifelse
  547.   /sfnts [
  548.     offsets tabs { concatstrings } forall
  549.     tabs {
  550.       0 4 getinterval tabdict exch get
  551.       dup type /stringtype ne { aload pop } if
  552.     } forall
  553.   ] def
  554. } bind def
  555.  
  556. % <glyfs> .dividesfnts <glyfs'>
  557. /.dividesfnts {
  558.   /glyfs exch def
  559.   /len1 0 glyfs { length add } forall def
  560.         % Determine where to split the glyfs by scanning loca.
  561.         % The very last entry in loca may be bogus.
  562.         % Note that some loca entries may be odd, but we can only
  563.         % split at even positions.
  564.         %
  565.         % Construct splitarray, the array of final lengths of
  566.         % the sfnts entries covering the glyfs (i.e., all but
  567.         % the first and last sfnts entries).
  568.     /prevsplit 0 def
  569.     /prevboundary 0 def
  570.     /splitarray [
  571.       0 1 numloca 1 sub {
  572.     getloca dup prevsplit maxstring add gt {
  573.       prevboundary prevsplit sub exch
  574.       /prevsplit prevboundary def
  575.     } if
  576.     dup 1 and 0 eq { /prevboundary exch def } { pop } ifelse
  577.       } for
  578.       len1 prevsplit sub
  579.     ] def
  580.     currentuserparams /VMReclaim get -2 vmreclaim
  581.     [
  582.         % Re-split the sfnts glyfs strings according to splitarray.
  583.         % We do this by iterating over the final segments defined
  584.         % by splitarray, and constructing them from pieces of the
  585.         % current glyfs strings.  We recycle the current strings
  586.         % when possible, to avoid stressing the allocator.
  587.       /sfnt_idx 0 def
  588.       /strpos 0 def
  589.       /avail () def
  590.       splitarray {
  591.     /seglen exch def
  592.     /segpos 0 def
  593.     avail length seglen ge
  594.       { avail 0 seglen getinterval /avail () def } { seglen string }
  595.     ifelse
  596.     {
  597.       /str glyfs sfnt_idx get def
  598.       /strlen str length def
  599.       /strleft strlen strpos sub def
  600.       seglen segpos sub strleft lt { exit } if
  601.         % Copy the (rest of the) string into the new segment.
  602.         % We know strleft <= segleft.
  603.       dup segpos str strpos strleft getinterval putinterval
  604.       /segpos segpos strleft add def
  605.       /avail str def
  606.       /sfnt_idx sfnt_idx 1 add def
  607.       /strpos 0 def
  608.       segpos seglen eq { exit } if
  609.     } loop
  610.         % Fill up the segment with an initial piece of the next
  611.         % existing glyfs string.  We know strleft > segleft.
  612.     /segleft seglen segpos sub def
  613.     dup segpos str strpos segleft getinterval putinterval
  614.     /strpos strpos segleft add def
  615.       } forall
  616.     ]
  617.     exch vmreclaim
  618. } bind def
  619.  
  620. % - .getpost -
  621. % Uses post, defines glyphencoding
  622. /.getpost {
  623.   /glyphencoding post null eq {
  624.     DEBUG { (post missing) = flush } if [ ]
  625.   } {
  626.     postformats post 0 getu32 .knownget {
  627.       DEBUG {
  628.     (post: format ) print
  629.     post 0 getu16 =only (,) print post 2 getu16 = flush
  630.       } if
  631.       post exch exec
  632.     } {
  633.       DEBUG { (post: unknown format ) print post 0 getu32 = flush } if [ ]
  634.     } ifelse
  635.   } ifelse def
  636. } bind def
  637.  
  638. % - .ttkeys <key> <value> ...
  639. /.ttkeys {
  640.   count /ttkeycount exch def
  641.   /upem head 18 getu16 def
  642.   /FontMatrix matrix
  643.   /FontBBox [ 36 2 42 { head exch gets16 upem div } for ]
  644.   nextxuid
  645.   tabdict /name .knownget {
  646.         % Find the names from the 'name' table.
  647.     /names exch def
  648.     /FontName names 6 findname not { curxuid 16 8 string cvrs } if
  649.       /fontname 1 index def
  650.     /FontInfo mark
  651.       names 0 findname { /Notice exch } if
  652.       names 1 findname { /FamilyName exch } if
  653.       names 4 findname { /FullName exch } if
  654.       names 5 findname { /Version exch } if
  655.   } {
  656.         % No name table, fabricate a FontName.
  657.     /FontName curxuid 16 8 string cvrs
  658.       /fontname 1 index def
  659.     /FontInfo mark
  660.   } ifelse
  661.         % Stack: ... /FontInfo mark key1 value1 ...
  662.   post null ne {
  663.     /ItalicAngle post 4 gets32 65536.0 div
  664.     /isFixedPitch post 12 getu32 0 ne
  665.     /UnderlinePosition post 8 gets16 upem div
  666.     /UnderlineThickness post 10 gets16 upem div
  667.   } if
  668.   counttomark 0 ne { .dicttomark } { pop pop } ifelse
  669.   /XUID [orgXUID 42 curxuid]
  670.   DEBUG {
  671.     tabs { .printtab } forall
  672.     [ sfnts { length } forall ] ==
  673.     count ttkeycount sub array astore dup { == } forall aload pop
  674.   } if
  675.   /sfnts sfnts
  676. } bind def
  677.  
  678. % ---------------- Standard TrueType font loading ---------------- %
  679.  
  680. % - .pickcmap -
  681. % Defines cmapsub, cmaptab
  682. /.pickcmap {
  683.   tabdict /cmap get
  684.         % The Apple cmap format is no help in determining the encoding.
  685.         % Look for a Microsoft table.  If we can't find one,
  686.         % just use the first table, whatever it is.
  687.   dup 4 8 getinterval exch             % the default
  688.   0 1 2 index 2 getu16 1 sub {
  689.     8 mul 4 add 1 index exch 8 getinterval
  690.     DEBUG {
  691.       (cmap: platform ) print dup 0 getu16 =only
  692.       ( encoding ) print dup 2 getu16 = flush
  693.     } if
  694.     dup 0 getu16 3 eq { exch 3 -1 roll pop exit } if pop
  695.   } for
  696.         % Stack: subentry table
  697.   /cmapsub 2 index def
  698.   exch 4 getu32 1 index length 1 index sub getinterval
  699.   /cmaptab exch def
  700. } bind def
  701.  
  702. % <glyph> .nname <_name>
  703. /.nname {
  704.   =string cvs (_) exch concatstrings cvn
  705. } bind def
  706.  
  707. % - .charkeys /CharStrings <charstrings> /Encoding <encoding>
  708. % Resets glyphencoding
  709. /.charkeys {
  710.   DEBUG {
  711.     (glyphencoding: length=) print glyphencoding dup length = === flush
  712.   } if
  713.         % Hack: if there is no usable post table but the cmap uses
  714.         % the Microsoft Unicode encoding, use ISOLatin1Encoding.
  715.   glyphencoding length 0 eq cmapsub 0 4 getinterval <00030001> eq and {
  716.     /glyphencoding ISOLatin1Encoding dup length array copy def
  717.   } if
  718.         % If necessary, fabricate additional glyphencoding entries
  719.         % to cover all of loca, or truncate glyphencoding.
  720.   glyphencoding length numloca lt {
  721.     /glyphencoding [ glyphencoding aload pop
  722.     counttomark 1 numloca 1 sub { .nname } for ] def
  723.   } {
  724.     /glyphencoding glyphencoding 0 numloca getinterval def
  725.   } ifelse
  726.         % Some badly designed Chinese fonts have a post table
  727.         % in which all glyphs other than 0 are named .null.
  728.         % Use CharStrings to keep track of the reverse map from
  729.         % names to glyphs, and don't let any name be used for
  730.         % more than one glyph.
  731.   /CharStrings glyphencoding dup length 1 add dict    % +1 for .notdef
  732.     0 1 3 index length 1 sub {
  733.         % Stack: glyphencoding dict index
  734.       2 index 1 index get 2 index 1 index known {
  735.         % The same name maps to more than one glyph.
  736.         % Change the name.
  737.     pop dup .nname 3 index 2 index 2 index put
  738.       } if
  739.       2 index exch 3 -1 roll put
  740.     } for exch pop
  741.         % If there is no .notdef entry, map it to glyph 0.
  742.   dup /.notdef known not { dup /.notdef 0 put } if
  743.   readonly
  744.   /Encoding
  745.     [ cmaptab cmaparray dup length 256 gt { 0 256 getinterval } if
  746.     { glyphencoding exch get } forall
  747.     counttomark 256 exch sub { /.notdef } repeat ]
  748.   DEBUG { (Encoding: ) print dup === flush } if
  749. } bind def
  750.  
  751. % -mark- <key> <value> ... .definettfont <font>
  752. /.definettfont {
  753.   /FontType 42
  754.   /PaintType 0
  755.   DEBUG {
  756.     (numloca=) print numloca =
  757.   } if
  758.   .dicttomark
  759.   end end dup /FontName get exch definefont
  760. } bind def
  761.  
  762. % <file> .loadttfont <type42font>
  763. /.loadttfont {
  764.   .loadttfonttables
  765.   .makesfnts
  766.   .getpost
  767.   .pickcmap
  768.   mark
  769.   .charkeys
  770.   .ttkeys
  771.   .definettfont
  772. } bind def
  773.  
  774. % ---------------- CIDFontType 2 font loading ---------------- %
  775.  
  776. % Create a string with N CIDs from the top of the stack.
  777. % <cid1> ... <cidN> <N> .makecidmap <string>
  778. /.makecidmap {
  779.   dup 2 mul string dup 3 -1 roll 1 sub 2 mul -2 0 {
  780.         % Stack: cids str str i2
  781.     2 copy 5 index -8 bitshift put
  782.     1 add 4 -1 roll 16#ff and put dup
  783.   } for pop
  784. } bind def
  785.  
  786. % -mark- <key> <value> ... .definettcidfont <font>
  787. /.definettcidfont {
  788.   /CIDFontName fontname
  789.   /CIDFontType 2
  790.   /CIDSystemInfo mark
  791.     /Registry (Adobe)
  792.     /Ordering (Japan1)        % adhoc
  793.     /Supplement 0
  794.   .dicttomark
  795.   /CharStrings mark /.notdef 0 .dicttomark
  796.         % The cmap isn't of any use even if it is present.
  797.         % Just construct an identity CIDMap covering all the glyphs.
  798.   mark 0 1 numloca 1 sub { } for
  799.   counttomark /cidcount exch def
  800.   cidcount maxstring le {
  801.         % Use a single string.
  802.     cidcount .makecidmap exch pop
  803.   } {
  804.         % We must use 2 strings.
  805.     maxstring .makecidmap counttomark 1 add 1 roll
  806.     counttomark .makecidmap exch pop exch 2 array astore
  807.   } ifelse
  808.   /CIDMap exch
  809.   /CIDCount cidcount
  810.   /GDBytes 2
  811.   .dicttomark
  812.   end end dup /CIDFontName get exch /CIDFont defineresource
  813. } bind def
  814.  
  815. % <file> .loadttcidfont <cidtype2font>
  816. /.loadttcidfont {
  817.   .loadttfonttables
  818.   .makesfnts
  819.     % CIDFontType2 fonts don't have a cmap: they are indexed by CID.
  820.   mark
  821.   .ttkeys
  822.   .definettcidfont
  823. } bind def
  824.  
  825. % ---------------- PDF TrueType font loading ---------------- %
  826.  
  827. % Strictly speaking, this code should be loaded only if we have a PDF
  828. % interpreter, but it's so closely tied to the rest of the code in this
  829. % file that we always include it.
  830.  
  831. % <plat+enc> .findcmap <subtable> true
  832. % <plat+enc> .findcmap false
  833. /.findcmap {
  834.   false exch tabdict /cmap get
  835.         % Some fonts have multiple cmaps with the same platform and
  836.         % encoding.  Use the first one we find.
  837.   0 1 2 index 2 getu16 1 sub {
  838.         % Stack: false plat+enc cmap index
  839.     8 mul 4 add 1 index exch 8 getinterval 
  840.     dup 0 4 getinterval 3 index eq {
  841.       4 getu32 1 index exch 1 index length 1 index sub getinterval
  842.       4 -1 roll not 4 2 roll exit
  843.     } if pop
  844.   } for
  845.         % Stack: false plat+enc cmap || subtable true plat+enc cmap
  846.   pop pop
  847. } bind def
  848.  
  849. % <subcmap> <chartoglyphmap> .pdfmapchars
  850. %   /CharStrings <charstrings> /Encoding <encoding>
  851. % Uses encoding
  852. /.pdfmapchars {
  853.   exch cmaparray /cmapencoding exch def
  854.     % Invert glyphencoding (post).
  855.   /inversepost glyphencoding length dict def
  856.   0 1 glyphencoding length 1 sub {
  857.     glyphencoding 1 index get exch inversepost 3 1 roll put
  858.   } for
  859.   /CharStrings mark 3 -1 roll {
  860.     dup type /arraytype eq {
  861.       exch /ch exch def { ch exch .pdfaddchar } forall
  862.     } {
  863.       .pdfaddchar
  864.     } ifelse
  865.   } forall
  866.     % Add a .notdef => 0 entry if needed.  Per Adobe's spec,
  867.     % .dicttomark (>>) adds pairs in top-to-bottom order.
  868.   /.notdef 0
  869.   .dicttomark
  870.   /Encoding encoding
  871. } bind def
  872. % <charname> <charcode> .pdfaddchar <charname> <glyph#>
  873. % <charname> <charcode> .pdfaddchar -
  874. /.pdfaddchar {
  875.   dup cmapencoding length lt {
  876.     cmapencoding exch get dup 0 eq {
  877.       pop .pdfaddpost
  878.     } if
  879.   } {
  880.     pop .pdfaddpost
  881.   } ifelse
  882. } bind def
  883. % <charname> .pdfaddpost <charname> <glyph#>
  884. % <charname> .pdfaddpost -
  885. /.pdfaddpost {
  886.   inversepost 1 index .knownget not { pop } if
  887. } bind def
  888.  
  889. % - .pdfcharkeys /CharStrings <charstrings> /Encoding <encoding>
  890. /.pdfcharkeys {
  891.     % The following algorithms are per the PDF Reference, Second Edition
  892.     % (PDF 1.3 reference manual).
  893.   encoding null eq {
  894.     .charkeys        % use default algorithm
  895.   } {
  896.     <00030001> .findcmap {
  897.       AdobeGlyphList .pdfmapchars
  898.     } {
  899.       <00010000> .findcmap {
  900.     .romanmacdict .pdfmapchars
  901.       } {
  902.     .charkeys    % use default algorithm
  903.       } ifelse
  904.     } ifelse
  905.   } ifelse
  906. } bind def
  907.  
  908. % <file> <encoding|null> .loadpdfttfont <type42font>
  909. /.loadpdfttfont {
  910.   exch .loadttfonttables
  911.   /encoding exch def
  912.   .makesfnts
  913.   .getpost
  914.   .pickcmap
  915.   mark
  916.   .pdfcharkeys
  917.   .ttkeys
  918.   .definettfont
  919. } bind def
  920.